#include<iostream>
using namespace std;
class A{
    public:
        int _x;
        int _y;
    public:
    // explicti A(int x)  用了explicit就没有直接赋值了
    A(int x)
    :_x(x)
    {
        cout << _x << endl;
    }
    A(const A& aa){
        _x = aa._x;
    }
};
class B{
public:
    int _x;
    int _y;
public:
// explicti B(intx,int y)
    B(int x,int y)
        : _x(x),_y(y)
    {
        cout << _x <<" "<<_y<<endl;

    }
    B(const B & bb)
    {
        _x = bb._x;
        _y = bb._y;
    }
};
void test_A(){
    A a1(10);
    A a2 = a1;
    // 30是常量
    const A &d4 = 30;

    // 隐式类型转换 <--> double a = 1;
    // 这里编译器做了优化，本来是构造+拷贝构造，然后直接把拷贝构造省了，创建了一个临时
    A a3 = 20;
}
void test_B(){
    B b1(1, 2);
    B b2 = b1;
    const B &b4 = {2, 3};
    // 隐式类型转换 <--> double a = 1;
    // 这里编译器做了优化，本来是构造+拷贝构造，然后直接把拷贝构造省了，创建了一个临时
    B b3 = { 1, 2 };
}
int main(){
    
    return 0;
}